{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from __future__ import print_function\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:  (49000, 3073)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3073)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3073)\n",
      "Test labels shape:  (1000,)\n",
      "dev data shape:  (500, 3073)\n",
      "dev labels shape:  (500,)\n"
     ]
    }
   ],
   "source": [
    "def get_CIFAR10_data(num_training=49000, num_val=1000, num_test=1000, num_dev=500):\n",
    "    cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "    \n",
    "    mask = np.arange(num_training, num_training+num_val)\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = np.arange(num_training)\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = np.arange(num_test)\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "    mask = np.random.choice(num_training, num_dev, replace=False)\n",
    "    X_dev = X_train[mask]\n",
    "    y_dev = y_train[mask]\n",
    "    \n",
    "    X_train = X_train.reshape((X_train.shape[0],-1))\n",
    "    X_val = X_val.reshape((X_val.shape[0],-1))\n",
    "    X_test = X_test.reshape((X_test.shape[0],-1))\n",
    "    X_dev = X_dev.reshape((X_dev.shape[0],-1))\n",
    "    \n",
    "    mean_img = np.mean(X_train, axis=0)\n",
    "    X_train -= mean_img\n",
    "    X_val -= mean_img\n",
    "    X_test -= mean_img\n",
    "    X_dev -= mean_img\n",
    "    \n",
    "    X_train = np.hstack((X_train, np.ones((X_train.shape[0], 1))))\n",
    "    X_val = np.hstack((X_val, np.ones((X_val.shape[0], 1))))\n",
    "    X_test = np.hstack((X_test, np.ones((X_test.shape[0], 1))))\n",
    "    X_dev = np.hstack((X_dev, np.ones((X_dev.shape[0], 1))))\n",
    "    \n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n",
    "\n",
    "    try:\n",
    "       del X_train, y_train\n",
    "       del X_test, y_test\n",
    "       print('Clear previously loaded data.')\n",
    "    except:\n",
    "       pass\n",
    "\n",
    "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n",
    "print('Train data shape: ', X_train.shape)\n",
    "print('Train labels shape: ', y_train.shape)\n",
    "print('Validation data shape: ', X_val.shape)\n",
    "print('Validation labels shape: ', y_val.shape)\n",
    "print('Test data shape: ', X_test.shape)\n",
    "print('Test labels shape: ', y_test.shape)\n",
    "print('dev data shape: ', X_dev.shape)\n",
    "print('dev labels shape: ', y_dev.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.335552\n",
      "sanity check: 2.302585\n",
      "numerical: -0.272258 analytic: -0.272259, relative error: 1.730940e-07\n",
      "numerical: 1.610883 analytic: 1.610883, relative error: 2.820299e-08\n",
      "numerical: -4.121773 analytic: -4.121773, relative error: 4.049360e-09\n",
      "numerical: -0.511019 analytic: -0.511019, relative error: 1.179668e-07\n",
      "numerical: 0.329540 analytic: 0.329540, relative error: 7.765497e-09\n",
      "numerical: 0.406474 analytic: 0.406474, relative error: 3.647645e-08\n",
      "numerical: 1.439669 analytic: 1.439668, relative error: 4.544701e-08\n",
      "numerical: 0.865497 analytic: 0.865497, relative error: 4.697240e-09\n",
      "numerical: 1.384401 analytic: 1.384401, relative error: 3.211594e-08\n",
      "numerical: 0.218452 analytic: 0.218452, relative error: 1.385402e-07\n"
     ]
    }
   ],
   "source": [
    "from cs231n.classifiers.softmax import softmax_loss_naive\n",
    "from cs231n.gradient_check import grad_check_sparse\n",
    "import time\n",
    "\n",
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0)\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (np.log(10)))\n",
    "\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.358530\n",
      "sanity check: 2.302585\n",
      "numerical: 0.233061 analytic: 0.233061, relative error: 9.693452e-08\n",
      "numerical: 1.076624 analytic: 1.076624, relative error: 4.479272e-08\n",
      "numerical: 0.503752 analytic: 0.503752, relative error: 8.706166e-08\n",
      "numerical: -0.248653 analytic: -0.248653, relative error: 7.624903e-08\n",
      "numerical: 1.160039 analytic: 1.160039, relative error: 1.265236e-08\n",
      "numerical: -2.210544 analytic: -2.210544, relative error: 1.374896e-08\n",
      "numerical: -0.423580 analytic: -0.423580, relative error: 5.426503e-08\n",
      "numerical: 0.538028 analytic: 0.538028, relative error: 7.784964e-08\n",
      "numerical: -1.520315 analytic: -1.520315, relative error: 6.694095e-08\n",
      "numerical: 2.722723 analytic: 2.722723, relative error: 4.120231e-10\n"
     ]
    }
   ],
   "source": [
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (np.log(10)))\n",
    "\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.343132\n",
      "sanity check: 2.302585\n",
      "numerical: 0.646640 analytic: 0.646640, relative error: 1.314349e-08\n",
      "numerical: -0.994996 analytic: -0.994996, relative error: 3.863588e-08\n",
      "numerical: -0.557622 analytic: -0.557622, relative error: 6.789051e-08\n",
      "numerical: 0.761707 analytic: 0.761707, relative error: 1.101823e-07\n",
      "numerical: 0.417492 analytic: 0.417492, relative error: 2.649655e-09\n",
      "numerical: 1.453960 analytic: 1.453960, relative error: 4.511221e-08\n",
      "numerical: 0.153557 analytic: 0.153557, relative error: 2.228311e-07\n",
      "numerical: 0.443247 analytic: 0.443247, relative error: 2.909782e-08\n",
      "numerical: -0.773126 analytic: -0.773126, relative error: 3.057113e-08\n",
      "numerical: -2.112620 analytic: -2.112620, relative error: 8.797299e-09\n"
     ]
    }
   ],
   "source": [
    "from cs231n.classifiers.softmax import softmax_loss_vectorized\n",
    "\n",
    "loss, grad = softmax_loss_vectorized(W, X_dev, y_dev, 0)\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (np.log(10)))\n",
    "\n",
    "f = lambda w: softmax_loss_vectorized(w, X_dev, y_dev, 0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.358530\n",
      "sanity check: 2.302585\n",
      "numerical: 1.451626 analytic: 1.451626, relative error: 2.375838e-08\n",
      "numerical: 0.143450 analytic: 0.143450, relative error: 6.958209e-08\n",
      "numerical: 3.903430 analytic: 3.903429, relative error: 1.365625e-08\n",
      "numerical: 0.140137 analytic: 0.140137, relative error: 5.167515e-08\n",
      "numerical: 0.655217 analytic: 0.655217, relative error: 9.418514e-09\n",
      "numerical: -1.901482 analytic: -1.901482, relative error: 2.828045e-09\n",
      "numerical: -0.127904 analytic: -0.127904, relative error: 6.915404e-08\n",
      "numerical: 0.933837 analytic: 0.933837, relative error: 6.885038e-09\n",
      "numerical: -2.458807 analytic: -2.458808, relative error: 1.716135e-08\n",
      "numerical: -0.076724 analytic: -0.076724, relative error: 1.031346e-06\n"
     ]
    }
   ],
   "source": [
    "loss, grad = softmax_loss_vectorized(W, X_dev, y_dev, 5e1)\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (np.log(10)))\n",
    "\n",
    "f = lambda w: softmax_loss_vectorized(w, X_dev, y_dev, 5e1)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.343132e+00 computed in 0.020376s\n",
      "Vectorized loss: 2.343132e+00 computed in 0.006639s\n",
      "Loss difference: 0.000000\n",
      "Gradient difference: 0.000000\n"
     ]
    }
   ],
   "source": [
    "tic = time.time()\n",
    "loss_naive, grads_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n",
    "\n",
    "tic = time.time()\n",
    "loss_vec, grads_vec = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('Vectorized loss: %e computed in %fs' % (loss_vec, toc - tic))\n",
    "print('Loss difference: %f' % np.abs(loss_naive - loss_vec))\n",
    "\n",
    "difference = np.linalg.norm(grads_vec-grads_naive, ord='fro')\n",
    "print('Gradient difference: %f' % difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from cs231n.classifiers import Softmax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/lzhang/documentation/cs231n/code/cs231n/assignment1/cs231n/classifiers/softmax.py:43: RuntimeWarning: divide by zero encountered in log\n",
      "  loss = -np.sum(np.log(correct_score/np.sum(stable_scores, axis=1)))\n",
      "/home/lzhang/documentation/cs231n/code/cs231n/assignment1/cs231n/classifiers/softmax.py:44: RuntimeWarning: overflow encountered in double_scalars\n",
      "  loss = loss/N + reg*np.sum(W*W)\n",
      "/home/lzhang/anaconda3/envs/cs231n/lib/python3.6/site-packages/numpy/core/_methods.py:32: RuntimeWarning: overflow encountered in reduce\n",
      "  return umr_sum(a, axis, dtype, out, keepdims)\n",
      "/home/lzhang/documentation/cs231n/code/cs231n/assignment1/cs231n/classifiers/softmax.py:44: RuntimeWarning: overflow encountered in multiply\n",
      "  loss = loss/N + reg*np.sum(W*W)\n",
      "/home/lzhang/documentation/cs231n/code/cs231n/assignment1/cs231n/classifiers/softmax.py:46: RuntimeWarning: overflow encountered in multiply\n",
      "  dW = dW/N + 2*reg*W\n",
      "/home/lzhang/anaconda3/envs/cs231n/lib/python3.6/site-packages/numpy/core/_methods.py:26: RuntimeWarning: invalid value encountered in reduce\n",
      "  return umr_maximum(a, axis, None, out, keepdims)\n",
      "/home/lzhang/documentation/cs231n/code/cs231n/assignment1/cs231n/classifiers/softmax.py:36: RuntimeWarning: overflow encountered in subtract\n",
      "  stable_scores = scores - np.max(scores, axis=1, keepdims=True)\n",
      "/home/lzhang/documentation/cs231n/code/cs231n/assignment1/cs231n/classifiers/softmax.py:36: RuntimeWarning: invalid value encountered in subtract\n",
      "  stable_scores = scores - np.max(scores, axis=1, keepdims=True)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 1.000000e-07 reg 2.500000e+04 train accuracy: 0.334082 val accuracy: 0.344000\n",
      "lr 1.000000e-07 reg 3.125000e+04 train accuracy: 0.319592 val accuracy: 0.336000\n",
      "lr 1.000000e-07 reg 3.750000e+04 train accuracy: 0.316592 val accuracy: 0.332000\n",
      "lr 1.000000e-07 reg 4.375000e+04 train accuracy: 0.307694 val accuracy: 0.324000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.308082 val accuracy: 0.319000\n",
      "lr 1.257500e-05 reg 2.500000e+04 train accuracy: 0.149061 val accuracy: 0.148000\n",
      "lr 1.257500e-05 reg 3.125000e+04 train accuracy: 0.094755 val accuracy: 0.102000\n",
      "lr 1.257500e-05 reg 3.750000e+04 train accuracy: 0.074041 val accuracy: 0.068000\n",
      "lr 1.257500e-05 reg 4.375000e+04 train accuracy: 0.105122 val accuracy: 0.099000\n",
      "lr 1.257500e-05 reg 5.000000e+04 train accuracy: 0.078367 val accuracy: 0.081000\n",
      "lr 2.505000e-05 reg 2.500000e+04 train accuracy: 0.096735 val accuracy: 0.095000\n",
      "lr 2.505000e-05 reg 3.125000e+04 train accuracy: 0.109224 val accuracy: 0.096000\n",
      "lr 2.505000e-05 reg 3.750000e+04 train accuracy: 0.061714 val accuracy: 0.054000\n",
      "lr 2.505000e-05 reg 4.375000e+04 train accuracy: 0.077612 val accuracy: 0.072000\n",
      "lr 2.505000e-05 reg 5.000000e+04 train accuracy: 0.071735 val accuracy: 0.081000\n",
      "lr 3.752500e-05 reg 2.500000e+04 train accuracy: 0.068429 val accuracy: 0.063000\n",
      "lr 3.752500e-05 reg 3.125000e+04 train accuracy: 0.107612 val accuracy: 0.109000\n",
      "lr 3.752500e-05 reg 3.750000e+04 train accuracy: 0.100265 val accuracy: 0.087000\n",
      "lr 3.752500e-05 reg 4.375000e+04 train accuracy: 0.100265 val accuracy: 0.087000\n",
      "lr 3.752500e-05 reg 5.000000e+04 train accuracy: 0.100265 val accuracy: 0.087000\n",
      "lr 5.000000e-05 reg 2.500000e+04 train accuracy: 0.066143 val accuracy: 0.069000\n",
      "lr 5.000000e-05 reg 3.125000e+04 train accuracy: 0.100265 val accuracy: 0.087000\n",
      "lr 5.000000e-05 reg 3.750000e+04 train accuracy: 0.100265 val accuracy: 0.087000\n",
      "lr 5.000000e-05 reg 4.375000e+04 train accuracy: 0.100265 val accuracy: 0.087000\n",
      "lr 5.000000e-05 reg 5.000000e+04 train accuracy: 0.100265 val accuracy: 0.087000\n",
      "best validation accuracy achieved during cross-validation: 0.344000\n"
     ]
    }
   ],
   "source": [
    "learning_range = [1e-7, 5e-5]\n",
    "regularization_range = [2.5e4, 5e4]\n",
    "\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_softmax = None\n",
    "\n",
    "num_iter = 1500\n",
    "learning_rates = np.linspace(learning_range[0], learning_range[1], 5)\n",
    "regularization_rates = np.linspace(regularization_range[0], regularization_range[1], 5)\n",
    "\n",
    "for lr in learning_rates:\n",
    "    for reg in regularization_rates:\n",
    "        softmax = Softmax()\n",
    "        loss_his = softmax.train(X_train, y_train, learning_rate=lr, reg=reg, num_iters=num_iter, batch_size=200, verbose=False)\n",
    "        \n",
    "        y_train_pred = softmax.predict(X_train)\n",
    "        train_acc = np.mean(y_train_pred==y_train)\n",
    "        \n",
    "        y_val_pred = softmax.predict(X_val)\n",
    "        val_acc = np.mean(y_val_pred==y_val)\n",
    "        \n",
    "        results[(lr, reg)] = (train_acc, val_acc)\n",
    "        \n",
    "        if val_acc > best_val:\n",
    "            best_val = val_acc\n",
    "            best_softmax = softmax\n",
    "\n",
    "for (lr, reg) in sorted(results):\n",
    "    (train_acc, val_acc) = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (lr, reg, train_acc, val_acc))\n",
    "        \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.341000\n"
     ]
    }
   ],
   "source": [
    "y_test_pred = best_softmax.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fd60b068eb8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "w = best_softmax.W[:-1,:] # strip out the bias\n",
    "w = w.reshape(32, 32, 3, 10)\n",
    "\n",
    "w_min, w_max = np.min(w), np.max(w)\n",
    "\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 5, i + 1)\n",
    "    \n",
    "    # Rescale the weights to be between 0 and 255\n",
    "    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n",
    "    plt.imshow(wimg.astype('uint8'))\n",
    "    plt.axis('off')\n",
    "    plt.title(classes[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
